package com.ilink.teacherservice.service.tingwu;


import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.ilink.teacherservice.mapper.FileContentMapper;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

@Service
public class FileResponseService {

    @Autowired
    private RestTemplate restTemplate;

    @Autowired
    private FileContentMapper fileContentMapper;

    // 用于存储文件 ID 和相应的内容
    private final ConcurrentHashMap<String, Map<String, JsonNode>> fileContentMap = new ConcurrentHashMap<>();

    private static JsonNode convertToJson(String json) {
        ObjectMapper mapper = new ObjectMapper();
        System.out.println("原始返回JSON String: " + json);
        try {
            return mapper.readTree(json);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public void generateCompletion(String fileId, String apiKey) {
        String url = "https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions";

        // 设置 HTTP 头信息
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        headers.set("Authorization", "Bearer " + apiKey);

        // 构建系统消息
        Map<String, String> systemMessage1 = new HashMap<>();
        systemMessage1.put("role", "system");
        systemMessage1.put("content", "You are a helpful assistant.");

        Map<String, String> systemMessage2 = new HashMap<>();
        systemMessage2.put("role", "system");
        systemMessage2.put("content", "fileid://" + fileId);

        // 定义三个用户消息
        String userMessageContent1 = "请根据文章内容生成一份中文导读，要求内容连贯，简洁明了，能够概括文章的核心内容。请直接输出导读内容。导读需要包含以下几个部分："+
                "\n第一个节点：title。从原始文本中提取标题"+
                "\n第二个节点：overview。用一段完整的话概括文本内容"+
                "\n第三个节点：key_points。用一个数组提取出若干个要点，这里要高度精炼"+
                "\n第四个节点：quick_view。用一个数组，用标题+内容的形式提取出文章的关键信息，其中内容要详细展开，便于阅读。标题title和内容content各作为一个子节点在数组中的一个节点。"+
                "\n最后将以上内容使用json形式返回，作为4个子节点一并放在introduction节点下。"+
                "\n请注意，即使文章内容不具有很强的逻辑性，无法按照格式生成内容，也要按照json格式返回，包含以上几个节点，并且节点内容为空值。";
        String userMessageContent2 = "请对文章内容进行中英互译，中文部分翻译成英文，英文部分翻译成中文。请直接输出翻译内容，使用json形式，json中包含属性“English” ";
        String userMessageContent3 = "生成一个用于思维导图的结构化文本，并将其放在nodeData键的值中，不能产生任何其他内容。并注意nodeData键的值应该是一个完整的对象，而不是一个数组。"+
                "nodeData的结构化文本要求："+
                "    \n  - 根节点的id必须为'root'，topic表示思维导图的主要主题。"+
                "    \n  - 子节点及其下级节点的id必须根据章节编号填写，并确保唯一性。"+
                "    \n  - 每个节点都必须包含topic字段来表示该节点的主题内容。"+
                "    \n  - 根节点可以包含一个children数组，子节点的children数组可以包含二级子节点。"+
                "    \n  - 最多支持三级子节点，即根节点下的子节点的子节点不能再包含children字段。"+
                "    \n  - 请注意，即使文章内容不具有很强的逻辑性，无法按照格式生成内容，也要按照json格式返回，包含至少一个根节点，并且用topic表示思维导图的主要主题。";
        Map<String, JsonNode> contentMap = new HashMap<>();

        // 进行三次请求，每次使用不同的用户消息
        String[] userMessages = {userMessageContent1, userMessageContent2, userMessageContent3};
        String[] keys = {"introduction", "translation", "mindmap"};

        for (int i = 0; i < 3; i++) {
            // 创建当前的用户消息
            Map<String, String> userMessage = new HashMap<>();
            userMessage.put("role", "user");
            userMessage.put("content", userMessages[i]);

            // 创建请求体
            Map<String, Object> requestBody = new HashMap<>();
            requestBody.put("model", "qwen-long");
            requestBody.put("stream", false);
            requestBody.put("messages", List.of(systemMessage1, systemMessage2, userMessage));

            if(i!=1){
                // 发送请求并获取响应
                String responseBody = makeRequest(url, headers, requestBody);
                System.out.println("第"+(i+1)+"次接口返回信息: " + responseBody);  // Debug output

                try {
                    JSONObject jsonResponse = new JSONObject(responseBody);
                    JSONArray choicesArray = jsonResponse.getJSONArray("choices");
                    if (choicesArray.length() > 0) {
                        JSONObject firstChoice = choicesArray.getJSONObject(0);
                        JSONObject messageObject = firstChoice.getJSONObject("message");
                        String content = messageObject.getString("content");

                        if (i == 1){
                            content = content.replace("```json\n", "");
                            content = content.concat("\"}");
                        }
                        // 处理字符串，移除不需要的部分
                        if (i == 0) {
                            content = content.replace("\\\"", "\"");
                            content = content.replace("```json\n", ""); // 去除开始标记
                            content = content.replace("\n```", ""); // 去除结束标记
                        }
                        if (i == 2) {
                            content = content.replace("\\\"", "\"");
                            content = content.replace("```json\n", ""); // 去除开始标记
                            content = content.replace("\n```", ""); // 去除结束标记
                        }


                        // 将字符串转换为 JSON 并存储到 Map 中
                        JsonNode jsonNode = convertToJson(content);
                        System.out.println("处理后的JSON内容: " + jsonNode);  // Debug output
                        contentMap.put(keys[i], jsonNode);

                    } else {
                        System.out.println("No content found for key: " + keys[i]);  // Debug output
                        contentMap.put(keys[i], null); // 处理没有内容的情况
                    }
                } catch (JSONException e) {
                    e.printStackTrace();
                    contentMap.put(keys[i], null); // 处理解析错误
                }
            }
        }

        // 将内容存储在 ConcurrentHashMap 中，方便后续使用
        fileContentMap.put(fileId, contentMap);
    }

    private String makeRequest(String url, HttpHeaders headers, Map<String, Object> requestBody) {
        HttpEntity<Map<String, Object>> requestEntity = new HttpEntity<>(requestBody, headers);
        ResponseEntity<String> response = restTemplate.exchange(url, HttpMethod.POST, requestEntity, String.class);
        return response.getBody();
    }

    // 获取存储的 JSON 内容
    // 获取存储的 JSON 内容
    public Map<String, JsonNode> getContent(String tongyiId) {
        return fileContentMap.getOrDefault(tongyiId, new HashMap<>());
    }

    // 删除存储的内容（可选）
    public void removeContent(String fileId) {
        fileContentMap.remove(fileId);
    }
}
